package com.zjmzxfzhl.modules.app.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zjmzxfzhl.common.core.constant.SysConstants;
import com.zjmzxfzhl.common.core.exception.SysException;
import com.zjmzxfzhl.common.core.util.CommonUtil;
import com.zjmzxfzhl.common.core.util.SecurityUtils;
import com.zjmzxfzhl.modules.app.entity.*;
import com.zjmzxfzhl.modules.app.form.AppDocVo;
import com.zjmzxfzhl.modules.app.form.AppTaskVo;
import com.zjmzxfzhl.modules.app.form.DocFilePath;
import com.zjmzxfzhl.modules.app.service.AppDocService;
import com.zjmzxfzhl.modules.app.service.AppTaskTagService;
import com.zjmzxfzhl.modules.app.service.AppTempTagService;
import com.zjmzxfzhl.modules.sys.entity.SysOrg;
import com.zjmzxfzhl.modules.sys.entity.SysUser;
import com.zjmzxfzhl.modules.sys.entity.vo.ElTree;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.zjmzxfzhl.common.core.base.BaseServiceImpl;
import com.zjmzxfzhl.modules.app.mapper.AppTemplateMapper;
import com.zjmzxfzhl.modules.app.service.AppTemplateService;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * Service
 * 
 * @author 张森荣
 */
@Service
public class AppTemplateServiceImpl extends BaseServiceImpl<AppTemplateMapper, AppTemplate>
        implements AppTemplateService {
    @Autowired
    private AppTempTagService appTempTagService;
    @Autowired
    private AppDocService appDocService;

    @Override
    public IPage<AppTemplate> list(IPage<AppTemplate> page, AppTemplate appTemplate) {
        return page.setRecords(baseMapper.list(page, appTemplate));
    }

    /**
     * 新增机构，自动计算机构级别、机构级次码、是否叶子
     *
     * @param appTemplate
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean saveAppTemplate(AppTemplate appTemplate) {
        //保存项目成员数组，标签数组
        List<AppTag> tags=null;
        if(appTemplate.getTags()!=null){
            tags=appTemplate.getTags();
        }
        List<DocFilePath> docFilePaths= null;
        if(appTemplate.getDocFilePath()!=null){
            docFilePaths=appTemplate.getDocFilePath();
        }

        //添加项目
        appTemplate =setAppTask(appTemplate);
        Boolean result = this.save(appTemplate);
        if(result==false){
            return result;
        }
        appTemplate=this.getById(appTemplate.getTempId());
        // 【1】 校验id是否重复.
        if (CommonUtil.isEmptyStr(appTemplate.getParentTempId())) {
            appTemplate.setTempLevel("1");
            appTemplate.setTempLevelCode(appTemplate.getTempId());
            appTemplate.setIsLeaf(SysConstants.USER_STATUS_1);
            result = this.updateById(appTemplate);
        } else {

            // 父节点
            AppTemplate parentAppTemplate = this.getById(appTemplate.getParentTempId());
            if (parentAppTemplate == null) {
                throw new SysException("保存失败,上级机构ID【" + appTemplate.getParentTempId() + "】不存在!");
            }
            // 【2】计算机构级次,机构级次码
            // 【2-a】设置新增机构的父机构是否叶子为否
            if (!SysConstants.IS_LEAF_0.equals(parentAppTemplate.getIsLeaf())) {
                parentAppTemplate.setIsLeaf(SysConstants.IS_LEAF_0);
                this.updateById(parentAppTemplate);
            }
            Integer TaskLevel = Integer.valueOf(parentAppTemplate.getTempLevel()) + 1;
            appTemplate.setTempLevel(TaskLevel.toString());
            appTemplate.setTempLevelCode(parentAppTemplate.getTempLevelCode() + "," + appTemplate.getTempId());

            // 【3】设置新增机构是否叶子为 是；
            appTemplate.setIsLeaf("1");
            result = this.updateById(appTemplate);
        }

        if(tags!=null){
            for (AppTag tag:tags) {
                AppTempTag appTempTag=new AppTempTag();
                appTempTag.setTempId(appTemplate.getTempId());
                appTempTag.setTagId(tag.getTagId());
                appTempTagService.saveAppTempTag(appTempTag);
            }
        }

        //添加模板附件
        if (docFilePaths != null && docFilePaths.size() > 0) {
            AppDoc appDoc=new AppDoc();
            appDoc.setDocFilePath(docFilePaths);
            appDoc.setDeleted("0");
            appDoc.setName("模板附件");
            appDoc.setDirId(appTemplate.getDirId());
            appDoc.setDocType("11");
            appDoc.setDocTypeId(appTemplate.getTempId());
            appDoc.setContent("模板: "+appTemplate.getName()+"的附件");
            appDocService.saveAppDoc(appDoc);
        }
        return result;
    }

    private AppTemplate setAppTask(AppTemplate appTemplate){
        if (appTemplate.getTempLevel() == null || "".equals(appTemplate.getTempLevel())) {
            appTemplate.setTempLevel("0");
        }
        if (appTemplate.getTempLevelCode() == null) {
            appTemplate.setTempLevelCode("");
        }
        if (appTemplate.getTempType() == null || "".equals(appTemplate.getTempType())) {
            appTemplate.setTempType("06");
        }
        if (appTemplate.getMatrix() == null || "".equals(appTemplate.getMatrix())) {
            appTemplate.setMatrix("02");
        }
        return appTemplate;
    }

    /**
     * 新增机构，自动计算机构级别、机构级次码、是否叶子
     *
     * @param appTemplate
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateAppTemplate(AppTemplate appTemplate) {
        //保存修改项目成员数组，标签数组
        List<AppTag> tags=null;
        if(appTemplate.getTags()!=null){
            tags=appTemplate.getTags();
        }
        appTemplate.setUpdateTime(new Date());
        Boolean result = this.updateById(appTemplate);
        if(result==false){
            return false;
        }

        if(tags!=null){
            AppTempTag appTempTag=new AppTempTag();
            appTempTag.setTempId(appTemplate.getTempId());
            appTempTagService.relationDel(appTempTag);
            for (AppTag tag:tags) {
                appTempTag.setTagId(tag.getTagId());
                appTempTagService.saveAppTempTag(appTempTag);
            }
        }
        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean delByIds(String ids) {
        Boolean result = true;
        String[] idsArr = ids.split(",");

        result = isRemove(idsArr);
        if (result == false) {
            return result;
        }
        for (String s:idsArr) {
            AppDocVo appDoc=new AppDocVo();
            appDoc.setDocType("11");
            appDoc.setDocTypeId(s);
            List<AppDocVo> appDocVoList= appDocService.getList(null, appDoc);
            for (AppDocVo doc:appDocVoList) {
                appDocService.removeById(doc.getDocId());
            }

            AppTemplate appTemplate=baseMapper.selectById(s);
            result= this.removeById(s);
            if(appTemplate.getParentTempId()!=null){
                inspectParent(appTemplate.getParentTempId());
            }
        }
        return result;
    }

    private boolean isRemove(String[] idsArr){
        Boolean result = true;
        for (String s:idsArr) {
            AppTemplate appTemplate = baseMapper.selectById(s);
            //项目不存在
            if (appTemplate == null) {
                result = false;
            }
            //不为叶子节点
            if ("0".equals(appTemplate.getIsLeaf())) {
                result = false;
            }
        }
        return result;
    }
    //检查父节点是否为子树
    private void inspectParent(String parentId){
        Integer total = this.count(new LambdaQueryWrapper<AppTemplate>().eq(AppTemplate::getParentTempId, parentId));
        if (total <= 0) {
            AppTemplate parentAppTemplate=this.getById(parentId);
            parentAppTemplate.setIsLeaf(SysConstants.USER_STATUS_1);
            this.updateById(parentAppTemplate);
        }
    }

    /**
     * 机构管理，机构树数据
     *
     * @return
     */
    @Override
    public List<ElTree> getTreeData(AppTemplate appTemplate) {
        List<AppTemplate> templateList = baseMapper.list(null, appTemplate);

        if (templateList != null) {
            return makeOrgTree(templateList);
        }
        return null;
    }

    /**
     * 生成机构树
     *
     * @param templateList
     * @return
     */
    public List<ElTree> makeOrgTree(List<AppTemplate> templateList) {
        Map<String, ElTree> orgMap = new LinkedHashMap<String, ElTree>();
        for (AppTemplate appTemplate : templateList) {
            ElTree elTree = new ElTree();
            elTree.setId(appTemplate.getTempId());
            elTree.setLabel(appTemplate.getName());
            elTree.setIsLeaf("1".equals(appTemplate.getIsLeaf()));
            elTree.setData(appTemplate);
            orgMap.put(appTemplate.getTempId(), elTree);
            if (CommonUtil.isNotEmptyStr(appTemplate.getParentTempId()) && orgMap.containsKey(appTemplate.getParentTempId())) {
                elTree.setParentId(appTemplate.getParentTempId());
                ElTree parentElTree = orgMap.get(appTemplate.getParentTempId());
                parentElTree.addChildren(elTree);
            }
        }

        List<ElTree> result = new ArrayList<ElTree>();
        orgMap.forEach((k, v) -> {
            if (CommonUtil.isEmptyStr(v.getParentId())) {
                result.add(v);
            }
        });
        List<ElTree> sortElTree=sort(result);

        return sortElTree;
    }


    /**
     * 排序
     *
     * @param items
     *            排序
     * @return 排序
     */
    private List<ElTree> sort(List<ElTree> items) {
        List<ElTree> result = new ArrayList<ElTree>();
        if (items != null) {
            Collections.sort(items, new Comparator<ElTree>() {
                public int compare(ElTree n1, ElTree n2) {
                    AppTemplate org1=(AppTemplate)n1.getData();
                    AppTemplate org2=(AppTemplate)n2.getData();
                    if (org1.getCreateTime()==null) {
                        return -1;
                    }
                    if (org2.getCreateTime()==null) {
                        return 1;
                    }
                    return org1.getCreateTime().compareTo(org2.getCreateTime());
                }
            });
            for (ElTree item : items) {
                result.add(item);
                item.setChildren(sort(item.getChildren()));
            }
        }
        return result;
    }

}
